home *** CD-ROM | disk | FTP | other *** search
/ Complete Linux / Complete Linux.iso / docs / apps / circuits / spice2g6.z / spice2g6 / spice / moseq2.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-11-21  |  32.3 KB  |  1,058 lines
  1. /* moseq2.f -- translated by f2c (version of 3 February 1990  3:36:42).
  2.    You must link the resulting object file with the libraries:
  3.     -lF77 -lI77 -lm -lc   (in that order)
  4. */
  5.  
  6. #include "f2c.h"
  7.  
  8. /* Common Block Declarations */
  9.  
  10. struct {
  11.     doublereal vto, beta, gamma, phi, phib, cox, xnsub, xnfs, xd, xj, xld, 
  12.         xlamda, uo, uexp, vbp, utra, vmax, xneff, xl, xw, vbi, von, vdsat,
  13.          qspof, beta0, beta1, cdrain, xqco, xqc, fnarrw, fshort;
  14.     integer lev;
  15. } mosarg_;
  16.  
  17. #define mosarg_1 mosarg_
  18.  
  19. struct {
  20.     doublereal omega, time, delta, delold[7], ag[7], vt, xni, egfet, xmu, 
  21.         sfactr;
  22.     integer mode, modedc, icalc, initf, method, iord, maxord, noncon, iterno, 
  23.         itemno, nosolv, modac, ipiv, ivmflg, ipostp, iscrch, iofile;
  24. } status_;
  25.  
  26. #define status_1 status_
  27.  
  28. struct {
  29.     doublereal twopi, xlog2, xlog10, root2, rad, boltz, charge, ctok, gmin, 
  30.         reltol, abstol, vntol, trtol, chgtol, eps0, epssil, epsox, pivtol,
  31.          pivrel;
  32. } knstnt_;
  33.  
  34. #define knstnt_1 knstnt_
  35.  
  36. /*<       subroutine moseq2(vds,vbs,vgs,gm,gds,gmbs, >*/
  37. /*<      1   qg,qc,qb,cggb,cgdb,cgsb,cbgb,cbdb,cbsb) >*/
  38. /* Subroutine */ int moseq2_(vds, vbs, vgs, gm, gds, gmbs, qg, qc, qb, cggb, 
  39.     cgdb, cgsb, cbgb, cbdb, cbsb)
  40. doublereal *vds, *vbs, *vgs, *gm, *gds, *gmbs, *qg, *qc, *qb, *cggb, *cgdb, *
  41.     cgsb, *cbgb, *cbdb, *cbsb;
  42. {
  43.     /* Initialized data */
  44.  
  45.     static doublereal sig1[4] = { 1.,-1.,1.,-1. };
  46.     static doublereal sig2[4] = { 1.,1.,-1.,-1. };
  47.  
  48.     /* System generated locals */
  49.     integer i_1;
  50.     doublereal d_1;
  51.  
  52.     /* Builtin functions */
  53.     double sqrt(), log(), exp(), atan(), cos();
  54.  
  55.     /* Local variables */
  56.     static doublereal barg, argd, argg, ueff, sarg, vbin, args, body, sphi, 
  57.         argv;
  58.     static integer iknt, jknt;
  59.     static doublereal expg, vpof, vgst, vgsx, sarg3, argv1, sphi3, d2bdb2, a, 
  60.         b, c;
  61.     extern /* Subroutine */ int mosq2_();
  62.     static doublereal poly4[8];
  63.     static integer i, j;
  64.     static doublereal d2sdb2, p, r, s, gdbdv, dfact, bsarg, argsd, ufact, 
  65.         xleff, argxd, cdson, dbxwd, ddxwd, gdson, argsq, gbson, argss, 
  66.         tsarg, daddb2, a1, argxs, a4[4], b4[4], dgddb2, dbxws, b1, c1, 
  67.         dasdb2, d1, r3, s2, gammd2, v1, v2, p0, p2, x4[8], y3, p3, p4, a3,
  68.          b3, delta4, bodys, sargv, vdson, vdsat1, fi, dbrgdb, dbargd, 
  69.         dgddvb;
  70.     static integer icharg;
  71.     static doublereal gamasd, gammad, ro, dsrgdb, dbargs, dgdvds, gamass, 
  72.         factor, dgsdvb, cdonco, xn, sbiarg, dgdvbs, dodvbs, dxndvb, 
  73.         dxndvd, dodvds, udenom, dudvgs, dudvds, dudvbs, dsdvgs, dsdvbs, 
  74.         xv, xvalid, dbsrdb, gdbdvs, xlfact, dldsat, vqchan, dqdsat, vl, 
  75.         dfunds, dfundg, dfundb, dldvgs, dldvds, dldvbs, clfact, deltal, 
  76.         didvds;
  77.     extern /* Subroutine */ int mqspof_();
  78.     static doublereal eta, arg, cfs, gmw, xwb, vth, xwd, xdv, xls, xlv, xws, 
  79.         arg1, arg2;
  80.  
  81. /*<       implicit double precision (a-h,o-z) >*/
  82.  
  83. /*     this routine evaluates the drain current, its derivatives and */
  84. /*     the charges associated with the gate, channel and bulk */
  85. /*     for mosfets */
  86.  
  87. /* spice version 2g.6  sccsid=mosarg 3/15/83 */
  88. /*<       common /mosarg/ vto,beta,gamma,phi,phib,cox,xnsub,xnfs,xd,xj,xld, >*/
  89. /*<      1   xlamda,uo,uexp,vbp,utra,vmax,xneff,xl,xw,vbi,von,vdsat,qspof, >*/
  90. /*<      2   beta0,beta1,cdrain,xqco,xqc,fnarrw,fshort,lev >*/
  91. /* spice version 2g.6  sccsid=status 3/15/83 */
  92. /*<       common /status/ omega,time,delta,delold(7),ag(7),vt,xni,egfet, >*/
  93. /*<      1   xmu,sfactr,mode,modedc,icalc,initf,method,iord,maxord,noncon, >*/
  94. /*<      2   iterno,itemno,nosolv,modac,ipiv,ivmflg,ipostp,iscrch,iofile >*/
  95. /* spice version 2g.6  sccsid=knstnt 3/15/83 */
  96. /*<       common /knstnt/ twopi,xlog2,xlog10,root2,rad,boltz,charge,ctok, >*/
  97. /*<      1   gmin,reltol,abstol,vntol,trtol,chgtol,eps0,epssil,epsox, >*/
  98. /*<      2   pivtol,pivrel >*/
  99.  
  100. /*<       dimension a4(4),b4(4),x4(8),poly4(8),sig1(4),sig2(4) >*/
  101. /*<       data sig1 / 1.0d0, -1.0d0, 1.0d0, -1.0d0/, >*/
  102. /*<      1     sig2 / 1.0d0,  1.0d0,-1.0d0, -1.0d0/ >*/
  103.  
  104. /*     icharg=1 causes charges to be computed */
  105. /*     icharg=0 bypasses the computation of charges */
  106.  
  107. /*<       icharg=1 >*/
  108.     icharg = 1;
  109. /*<       if (mode.ne.1.and.xqco.le.0.5d0) go to 100 >*/
  110.     if (status_1.mode != 1 && mosarg_1.xqco <= .5) {
  111.     goto L100;
  112.     }
  113. /*<       icharg=0 >*/
  114.     icharg = 0;
  115. /*<       if (xqco.gt.0.5d0) go to 100 >*/
  116.     if (mosarg_1.xqco > .5) {
  117.     goto L100;
  118.     }
  119. /*<       if (modedc.eq.2.and.nosolv.ne.0) icharg=1 >*/
  120.     if (status_1.modedc == 2 && status_1.nosolv != 0) {
  121.     icharg = 1;
  122.     }
  123. /*<       if (initf.eq.4) icharg=1 >*/
  124.     if (status_1.initf == 4) {
  125.     icharg = 1;
  126.     }
  127.  
  128. /*  compute some useful quantities */
  129.  
  130. /*<   100 if (vbs.gt.0.0d0) go to 110 >*/
  131. L100:
  132.     if (*vbs > 0.) {
  133.     goto L110;
  134.     }
  135. /*<       sarg=dsqrt(phi-vbs) >*/
  136.     sarg = sqrt(mosarg_1.phi - *vbs);
  137. /*<       tsarg=sarg+sarg >*/
  138.     tsarg = sarg + sarg;
  139. /*<       dsrgdb=-0.5d0/sarg >*/
  140.     dsrgdb = -.5 / sarg;
  141. /*<       d2sdb2=+0.5d0*dsrgdb/(phi-vbs) >*/
  142.     d2sdb2 = dsrgdb * .5 / (mosarg_1.phi - *vbs);
  143. /*<       go to 120 >*/
  144.     goto L120;
  145. /*<   110 sphi=dsqrt(phi) >*/
  146. L110:
  147.     sphi = sqrt(mosarg_1.phi);
  148. /*<       sphi3=phi*sphi >*/
  149.     sphi3 = mosarg_1.phi * sphi;
  150. /*<       sarg=sphi/(1.0d0+0.5d0*vbs/phi) >*/
  151.     sarg = sphi / (*vbs * .5 / mosarg_1.phi + 1.);
  152. /*<       tsarg=sarg+sarg >*/
  153.     tsarg = sarg + sarg;
  154. /*<       dsrgdb=-0.5d0*sarg*sarg/sphi3 >*/
  155.     dsrgdb = sarg * -.5 * sarg / sphi3;
  156. /*<       d2sdb2=-dsrgdb*sarg/sphi3 >*/
  157.     d2sdb2 = -dsrgdb * sarg / sphi3;
  158. /*<   120 if ((vds-vbs).lt.0.0d0) go to 130 >*/
  159. L120:
  160.     if (*vds - *vbs < 0.) {
  161.     goto L130;
  162.     }
  163. /*<       barg=dsqrt(phi+vds-vbs) >*/
  164.     barg = sqrt(mosarg_1.phi + *vds - *vbs);
  165. /*<       dbrgdb=-0.5d0/barg >*/
  166.     dbrgdb = -.5 / barg;
  167. /*<       d2bdb2=+0.5d0*dbrgdb/(phi+vds-vbs) >*/
  168.     d2bdb2 = dbrgdb * .5 / (mosarg_1.phi + *vds - *vbs);
  169. /*<       go to 200 >*/
  170.     goto L200;
  171. /*<   130 barg=sphi/(1.0d0+0.5d0*(vbs-vds)/phi) >*/
  172. L130:
  173.     barg = sphi / ((*vbs - *vds) * .5 / mosarg_1.phi + 1.);
  174. /*<       dbrgdb=-0.5d0*barg*barg/sphi3 >*/
  175.     dbrgdb = barg * -.5 * barg / sphi3;
  176. /*<       d2bdb2=-dbrgdb*barg/sphi3 >*/
  177.     d2bdb2 = -dbrgdb * barg / sphi3;
  178.  
  179. /*  calculate threshold voltage (von) */
  180. /*     narrow-channel effect */
  181.  
  182. /*<   200 factor=0.125d0*fnarrw*twopi*epssil/cox*xl >*/
  183. L200:
  184.     factor = mosarg_1.fnarrw * .125 * knstnt_1.twopi * knstnt_1.epssil / 
  185.         mosarg_1.cox * mosarg_1.xl;
  186. /*<       eta=1.0d0+factor >*/
  187.     eta = factor + 1.;
  188. /*<       vbin=vbi+factor*(phi-vbs) >*/
  189.     vbin = mosarg_1.vbi + factor * (mosarg_1.phi - *vbs);
  190. /*<       if (gamma.le.0.0d0) go to 215 >*/
  191.     if (mosarg_1.gamma <= 0.) {
  192.     goto L215;
  193.     }
  194. /*<       if (xnsub.le.0.0d0) go to 215 >*/
  195.     if (mosarg_1.xnsub <= 0.) {
  196.     goto L215;
  197.     }
  198. /*<       xwd=xd*barg >*/
  199.     xwd = mosarg_1.xd * barg;
  200. /*<       xws=xd*sarg >*/
  201.     xws = mosarg_1.xd * sarg;
  202.  
  203. /*     short-channel effect with vds .ne. 0.0d0 */
  204.  
  205. /*<       argss=0.0d0 >*/
  206.     argss = 0.;
  207. /*<       argsd=0.0d0 >*/
  208.     argsd = 0.;
  209. /*<       dbargs=0.0d0 >*/
  210.     dbargs = 0.;
  211. /*<       dbargd=0.0d0 >*/
  212.     dbargd = 0.;
  213. /*<       dgdvds=0.0d0 >*/
  214.     dgdvds = 0.;
  215. /*<       dgddb2=0.0d0 >*/
  216.     dgddb2 = 0.;
  217. /*<       if (xj.le.0.0d0) go to 205 >*/
  218.     if (mosarg_1.xj <= 0.) {
  219.     goto L205;
  220.     }
  221. /*<       argxs=1.0d0+2.0d0*xws/xj >*/
  222.     argxs = xws * 2. / mosarg_1.xj + 1.;
  223. /*<       args=dsqrt(argxs) >*/
  224.     args = sqrt(argxs);
  225. /*<       argss=0.5d0*xj/xl*(args-1.0d0) >*/
  226.     argss = mosarg_1.xj * .5 / mosarg_1.xl * (args - 1.);
  227. /*<       argxd=1.0d0+2.0d0*xwd/xj >*/
  228.     argxd = xwd * 2. / mosarg_1.xj + 1.;
  229. /*<       argd=dsqrt(argxd) >*/
  230.     argd = sqrt(argxd);
  231. /*<       argsd=0.5d0*xj/xl*(argd-1.0d0) >*/
  232.     argsd = mosarg_1.xj * .5 / mosarg_1.xl * (argd - 1.);
  233. /*<   205 gamasd=gamma*(1.0d0-argss-argsd) >*/
  234. L205:
  235.     gamasd = mosarg_1.gamma * (1. - argss - argsd);
  236. /*<       gamass=gamma*(1.0d0-2.0d0*argss) >*/
  237.     gamass = mosarg_1.gamma * (1. - argss * 2.);
  238. /*<       dbxwd=xd*dbrgdb >*/
  239.     dbxwd = mosarg_1.xd * dbrgdb;
  240. /*<       dbxws=xd*dsrgdb >*/
  241.     dbxws = mosarg_1.xd * dsrgdb;
  242. /*<       if (xj.le.0.0d0) go to 210 >*/
  243.     if (mosarg_1.xj <= 0.) {
  244.     goto L210;
  245.     }
  246. /*<       dbargs=0.5d0/xl*dbxws/args >*/
  247.     dbargs = .5 / mosarg_1.xl * dbxws / args;
  248. /*<       dbargd=0.5d0/xl*dbxwd/argd >*/
  249.     dbargd = .5 / mosarg_1.xl * dbxwd / argd;
  250. /*<       dasdb2=-xd*( d2sdb2+dsrgdb*dsrgdb*xd/(xj*argxs) )/(xl*args) >*/
  251.     dasdb2 = -mosarg_1.xd * (d2sdb2 + dsrgdb * dsrgdb * mosarg_1.xd / (
  252.         mosarg_1.xj * argxs)) / (mosarg_1.xl * args);
  253. /*<       daddb2=-xd*( d2bdb2+dbrgdb*dbrgdb*xd/(xj*argxd) )/(xl*argd) >*/
  254.     daddb2 = -mosarg_1.xd * (d2bdb2 + dbrgdb * dbrgdb * mosarg_1.xd / (
  255.         mosarg_1.xj * argxd)) / (mosarg_1.xl * argd);
  256. /*<       dgddb2=-0.5d0*gamma*(dasdb2+daddb2) >*/
  257.     dgddb2 = mosarg_1.gamma * -.5 * (dasdb2 + daddb2);
  258. /*<   210 dgddvb=-gamma*(dbargs+dbargd) >*/
  259. L210:
  260.     dgddvb = -mosarg_1.gamma * (dbargs + dbargd);
  261. /*<       dgsdvb=-2.0d0*gamma*dbargs >*/
  262.     dgsdvb = mosarg_1.gamma * -2. * dbargs;
  263. /*<       if (xj.le.0.0d0) go to 220 >*/
  264.     if (mosarg_1.xj <= 0.) {
  265.     goto L220;
  266.     }
  267. /*<       ddxwd=-dbxwd >*/
  268.     ddxwd = -dbxwd;
  269. /*<       dgdvds=-gamma*0.5d0/xl*ddxwd/argd >*/
  270.     dgdvds = -mosarg_1.gamma * .5 / mosarg_1.xl * ddxwd / argd;
  271. /*<       go to 220 >*/
  272.     goto L220;
  273. /*<   215 gamasd=gamma >*/
  274. L215:
  275.     gamasd = mosarg_1.gamma;
  276. /*<       gamass=gamma >*/
  277.     gamass = mosarg_1.gamma;
  278. /*<       gammad=gamma >*/
  279.     gammad = mosarg_1.gamma;
  280. /*<       dgddvb=0.0d0 >*/
  281.     dgddvb = 0.;
  282. /*<       dgsdvb=0.0d0 >*/
  283.     dgsdvb = 0.;
  284. /*<       dgdvds=0.0d0 >*/
  285.     dgdvds = 0.;
  286. /*<       dgddb2=0.0d0 >*/
  287.     dgddb2 = 0.;
  288. /*<   220 von=vbin+gamasd*sarg >*/
  289. L220:
  290.     mosarg_1.von = vbin + gamasd * sarg;
  291. /*     write(iofile,221) von,vbin,vbi,gamasd,argss,argsd,xj */
  292. /*<   221 format ('0msg1:'/1p7d10.2) >*/
  293. /* L221: */
  294. /*<       vth=von >*/
  295.     vth = mosarg_1.von;
  296. /*<       vdsat=0.0d0 >*/
  297.     mosarg_1.vdsat = 0.;
  298. /*<   225 if (xnfs.eq.0.0d0.or.cox.eq.0.0d0) go to 230 >*/
  299. /* L225: */
  300.     if (mosarg_1.xnfs == 0. || mosarg_1.cox == 0.) {
  301.     goto L230;
  302.     }
  303. /*<       cfs=charge*xnfs >*/
  304.     cfs = knstnt_1.charge * mosarg_1.xnfs;
  305. /*<       cdonco=-(gamasd*dsrgdb+dgddvb*sarg)+factor >*/
  306.     cdonco = -(gamasd * dsrgdb + dgddvb * sarg) + factor;
  307. /*<       xn=1.0d0+cfs/cox*xw*xl+cdonco >*/
  308.     xn = cfs / mosarg_1.cox * mosarg_1.xw * mosarg_1.xl + 1. + cdonco;
  309. /*<       von=von+vt*xn >*/
  310.     mosarg_1.von += status_1.vt * xn;
  311. /*     write (iofile,226) von,cdonco,xn,cfs,xd */
  312. /*<   226 format(' msg2:'/1p6d10.2) >*/
  313. /* L226: */
  314. /*<       argg=1.0d0/(vt*xn) >*/
  315.     argg = 1. / (status_1.vt * xn);
  316. /*<       vgst=vgs-von >*/
  317.     vgst = *vgs - mosarg_1.von;
  318. /*<       go to 300 >*/
  319.     goto L300;
  320. /*<   230 vgst=vgs-von >*/
  321. L230:
  322.     vgst = *vgs - mosarg_1.von;
  323. /*<       if (vgs.gt.von) go to 300 >*/
  324.     if (*vgs > mosarg_1.von) {
  325.     goto L300;
  326.     }
  327.  
  328. /*  cutoff region */
  329.  
  330. /*<       gds=0.0d0 >*/
  331.     *gds = 0.;
  332. /*<       go to 1050 >*/
  333.     goto L1050;
  334.  
  335. /*  compute some more useful quantities */
  336.  
  337. /*<   300 sarg3=sarg*sarg*sarg >*/
  338. L300:
  339.     sarg3 = sarg * sarg * sarg;
  340. /*<       sbiarg=dsqrt(phib) >*/
  341.     sbiarg = sqrt(mosarg_1.phib);
  342. /*<       gammad=gamasd >*/
  343.     gammad = gamasd;
  344. /*<       dgdvbs=dgddvb >*/
  345.     dgdvbs = dgddvb;
  346. /*<       body=barg*barg*barg-sarg3 >*/
  347.     body = barg * barg * barg - sarg3;
  348. /*<       gdbdv=2.0d0*gammad*(barg*barg*dbrgdb-sarg*sarg*dsrgdb) >*/
  349.     gdbdv = gammad * 2. * (barg * barg * dbrgdb - sarg * sarg * dsrgdb);
  350. /*<       dodvbs=-factor+dgdvbs*sarg+gammad*dsrgdb >*/
  351.     dodvbs = -factor + dgdvbs * sarg + gammad * dsrgdb;
  352. /*<       if (xnfs.eq.0.0d0) go to 400 >*/
  353.     if (mosarg_1.xnfs == 0.) {
  354.     goto L400;
  355.     }
  356. /*<       if (cox.eq.0.0d0) go to 410 >*/
  357.     if (mosarg_1.cox == 0.) {
  358.     goto L410;
  359.     }
  360. /*<       dxndvb=2.0d0*dgdvbs*dsrgdb+gammad*d2sdb2+dgddb2*sarg >*/
  361.     dxndvb = dgdvbs * 2. * dsrgdb + gammad * d2sdb2 + dgddb2 * sarg;
  362. /*<       dodvbs=dodvbs+vt*dxndvb >*/
  363.     dodvbs += status_1.vt * dxndvb;
  364. /*<       dxndvd=dgdvds*dsrgdb >*/
  365.     dxndvd = dgdvds * dsrgdb;
  366. /*<       dodvds=dgdvds*sarg+vt*dxndvd >*/
  367.     dodvds = dgdvds * sarg + status_1.vt * dxndvd;
  368.  
  369. /*  evaluate effective mobility and its derivatives */
  370.  
  371. /*<   400 if (cox.le.0.0d0) go to 410 >*/
  372. L400:
  373.     if (mosarg_1.cox <= 0.) {
  374.     goto L410;
  375.     }
  376. /*<       udenom=vgst >*/
  377.     udenom = vgst;
  378. /*<       if (udenom.le.vbp) go to 410 >*/
  379.     if (udenom <= mosarg_1.vbp) {
  380.     goto L410;
  381.     }
  382. /*<       ufact=dexp(uexp*dlog(vbp/udenom)) >*/
  383.     ufact = exp(mosarg_1.uexp * log(mosarg_1.vbp / udenom));
  384. /*<       ueff=uo*ufact >*/
  385.     ueff = mosarg_1.uo * ufact;
  386. /*<       dudvgs=-ufact*uexp/udenom >*/
  387.     dudvgs = -ufact * mosarg_1.uexp / udenom;
  388. /*<       dudvds=0.0d0 >*/
  389.     dudvds = 0.;
  390. /*<       dudvbs=uexp*ufact*dodvbs/vgst >*/
  391.     dudvbs = mosarg_1.uexp * ufact * dodvbs / vgst;
  392. /*<       go to 500 >*/
  393.     goto L500;
  394. /*<   410 ufact=1.0d0 >*/
  395. L410:
  396.     ufact = 1.;
  397. /*<       ueff=uo >*/
  398.     ueff = mosarg_1.uo;
  399. /*<       dudvgs=0.0d0 >*/
  400.     dudvgs = 0.;
  401. /*<       dudvds=0.0d0 >*/
  402.     dudvds = 0.;
  403. /*<       dudvbs=0.0d0 >*/
  404.     dudvbs = 0.;
  405.  
  406. /*     evaluate saturation voltage and its derivatives according to */
  407. /*     grove-frohman equation */
  408.  
  409. /*<   500 vgsx=vgs >*/
  410. L500:
  411.     vgsx = *vgs;
  412. /*<       gammad=gamasd/eta >*/
  413.     gammad = gamasd / eta;
  414. /*<       dgdvbs=dgddvb >*/
  415.     dgdvbs = dgddvb;
  416. /*<       if (xnfs.ne.0.0d0.and.cox.ne.0.0d0) >*/
  417. /*<      1   vgsx=dmax1(vgs,von) >*/
  418.     if (mosarg_1.xnfs != 0. && mosarg_1.cox != 0.) {
  419.     vgsx = max(*vgs,mosarg_1.von);
  420.     }
  421. /*<   505 if (gammad.le.0.0d0) go to 535 >*/
  422. /* L505: */
  423.     if (gammad <= 0.) {
  424.     goto L535;
  425.     }
  426. /*<       gammd2=gammad*gammad >*/
  427.     gammd2 = gammad * gammad;
  428. /*<       argv=(vgsx-vbin)/eta+phi-vbs >*/
  429.     argv = (vgsx - vbin) / eta + mosarg_1.phi - *vbs;
  430. /*<       if (argv.le.0.0d0) go to 540 >*/
  431.     if (argv <= 0.) {
  432.     goto L540;
  433.     }
  434. /*<       arg=dsqrt(1.0d0+4.0d0*argv/gammd2) >*/
  435.     arg = sqrt(argv * 4. / gammd2 + 1.);
  436. /*<       vdsat=(vgsx-vbin)/eta+gammd2*(1.0d0-arg)/2.0d0 >*/
  437.     mosarg_1.vdsat = (vgsx - vbin) / eta + gammd2 * (1. - arg) / 2.;
  438. /*<       vdsat=dmax1(vdsat,0.0d0) >*/
  439.     mosarg_1.vdsat = max(mosarg_1.vdsat,0.);
  440. /*<   510 if (icharg.eq.0) go to 530 >*/
  441. /* L510: */
  442.     if (icharg == 0) {
  443.     goto L530;
  444.     }
  445. /*<       arg1=gammd2/(eta*eta) >*/
  446.     arg1 = gammd2 / (eta * eta);
  447. /*<       arg2=vds-0.5d0*arg1 >*/
  448.     arg2 = *vds - arg1 * .5;
  449. /*<       argsq=(arg2+0.5d0*arg1+phi-vbs)*arg1 >*/
  450.     argsq = (arg2 + arg1 * .5 + mosarg_1.phi - *vbs) * arg1;
  451. /*<       if (argsq.ge.0.0d0) go to 515 >*/
  452.     if (argsq >= 0.) {
  453.     goto L515;
  454.     }
  455. /*<       vpof=vth >*/
  456.     vpof = vth;
  457. /*<       go to 520 >*/
  458.     goto L520;
  459. /*<   515 vpof=vbin+eta*(arg2+0.5d0*arg1+dsqrt(argsq)) >*/
  460. L515:
  461.     vpof = vbin + eta * (arg2 + arg1 * .5 + sqrt(argsq));
  462. /*<   520 argv1=(vpof-vbin)/eta+phi-vbs >*/
  463. L520:
  464.     argv1 = (vpof - vbin) / eta + mosarg_1.phi - *vbs;
  465. /*<       if (argv1.gt.0.0d0) go to 525 >*/
  466.     if (argv1 > 0.) {
  467.     goto L525;
  468.     }
  469. /*<       vdsat1=0.0d0 >*/
  470.     vdsat1 = 0.;
  471. /*<       go to 530 >*/
  472.     goto L530;
  473. /*<   525 arg1=dsqrt(1.0d0+4.0d0*argv1/gammd2) >*/
  474. L525:
  475.     arg1 = sqrt(argv1 * 4. / gammd2 + 1.);
  476. /*<       vdsat1=(vpof-vbin)/eta+gammd2*(1.0d0-arg1)/2.0d0 >*/
  477.     vdsat1 = (vpof - vbin) / eta + gammd2 * (1. - arg1) / 2.;
  478. /*<       vdsat1=dmax1(vdsat1,0.0d0) >*/
  479.     vdsat1 = max(vdsat1,0.);
  480. /*<   530 dsdvgs=(1.0d0-1.0d0/arg)/eta >*/
  481. L530:
  482.     dsdvgs = (1. - 1. / arg) / eta;
  483. /*<       dsdvbs=(gammad*(1.0d0-arg)+2.0d0*argv/(gammad*arg))/eta*dgdvbs+ >*/
  484. /*<      1       1.0d0/arg+factor*dsdvgs >*/
  485.     dsdvbs = (gammad * (1. - arg) + argv * 2. / (gammad * arg)) / eta * 
  486.         dgdvbs + 1. / arg + factor * dsdvgs;
  487. /*<       go to 545 >*/
  488.     goto L545;
  489. /*<   535 vdsat=dmax1((vgsx-vbin)/eta,0.0d0) >*/
  490. L535:
  491. /* Computing MAX */
  492.     d_1 = (vgsx - vbin) / eta;
  493.     mosarg_1.vdsat = max(0.,d_1);
  494. /*<       vpof=dmax1((eta*vds+vbin),0.0d0) >*/
  495. /* Computing MAX */
  496.     d_1 = eta * *vds + vbin;
  497.     vpof = max(0.,d_1);
  498. /*<       vdsat1=dmax1((vpof-vbin)/eta,0.0d0) >*/
  499. /* Computing MAX */
  500.     d_1 = (vpof - vbin) / eta;
  501.     vdsat1 = max(0.,d_1);
  502. /*<       dsdvgs=1.0d0 >*/
  503.     dsdvgs = 1.;
  504. /*<       dsdvbs=0.0d0 >*/
  505.     dsdvbs = 0.;
  506. /*<       go to 545 >*/
  507.     goto L545;
  508. /*<   540 vdsat=0.0d0 >*/
  509. L540:
  510.     mosarg_1.vdsat = 0.;
  511. /*<       vpof=vth >*/
  512.     vpof = vth;
  513. /*<       vdsat1=0.0d0 >*/
  514.     vdsat1 = 0.;
  515. /*<       dsdvgs=0.0d0 >*/
  516.     dsdvgs = 0.;
  517. /*<       dsdvbs=0.0d0 >*/
  518.     dsdvbs = 0.;
  519.  
  520. /*     store vdsat as above in vpof (pinch-off) */
  521.  
  522. /*<   545 if (vmax.le.0.0d0) go to 600 >*/
  523. L545:
  524.     if (mosarg_1.vmax <= 0.) {
  525.     goto L600;
  526.     }
  527.  
  528. /*     evaluate saturation voltage and its derivatives according to */
  529. /*     baum's theory of scattering velocity saturation */
  530.  
  531. /*<       gammd2=gammad*gammad >*/
  532.     gammd2 = gammad * gammad;
  533. /*<       v1=(vgsx-vbin)/eta+phi-vbs >*/
  534.     v1 = (vgsx - vbin) / eta + mosarg_1.phi - *vbs;
  535. /*<       v2=phi-vbs >*/
  536.     v2 = mosarg_1.phi - *vbs;
  537. /*<       xv=vmax*xl/ueff >*/
  538.     xv = mosarg_1.vmax * mosarg_1.xl / ueff;
  539. /*<       a1=gammad/0.75d0 >*/
  540.     a1 = gammad / .75;
  541. /*<       b1=-2.0d0*(v1+xv) >*/
  542.     b1 = (v1 + xv) * -2.;
  543. /*<       c1=-2.0d0*gammad*xv >*/
  544.     c1 = gammad * -2. * xv;
  545. /*<       d1=2.0d0*v1*(v2+xv)-v2*v2-4.0d0/3.0d0*gammad*sarg3 >*/
  546.     d1 = v1 * 2. * (v2 + xv) - v2 * v2 - gammad * 1.3333333333333333 * sarg3;
  547. /*<       a=-b1 >*/
  548.     a = -b1;
  549. /*<       b=a1*c1-4.0d0*d1 >*/
  550.     b = a1 * c1 - d1 * 4.;
  551. /*<       c=-d1*(a1*a1-4.0d0*b1)-c1*c1 >*/
  552.     c = -d1 * (a1 * a1 - b1 * 4.) - c1 * c1;
  553. /*<       r=-a*a/3.0d0+b >*/
  554.     r = -a * a / 3. + b;
  555. /*<       s=2.0d0*a*a*a/27.0d0-a*b/3.0d0+c >*/
  556.     s = a * 2. * a * a / 27. - a * b / 3. + c;
  557. /*<       r3=r*r*r >*/
  558.     r3 = r * r * r;
  559. /*<       s2=s*s >*/
  560.     s2 = s * s;
  561. /*<       p=s2/4.0d0+r3/27.0d0 >*/
  562.     p = s2 / 4. + r3 / 27.;
  563. /*<       p0=dabs(p) >*/
  564.     p0 = abs(p);
  565. /*<       p2=dsqrt(p0) >*/
  566.     p2 = sqrt(p0);
  567. /*<       if (p.ge.0.0d0) go to 550 >*/
  568.     if (p >= 0.) {
  569.     goto L550;
  570.     }
  571. /*<       ro=dsqrt(s2/4.0d0+p0) >*/
  572.     ro = sqrt(s2 / 4. + p0);
  573. /*<       ro=dlog(ro)/3.0d0 >*/
  574.     ro = log(ro) / 3.;
  575. /*<       ro=dexp(ro) >*/
  576.     ro = exp(ro);
  577. /*<       fi=datan(-2.0d0*p2/s) >*/
  578.     fi = atan(p2 * -2. / s);
  579. /*<       y3=2.0d0*ro*dcos(fi/3.0d0)-a/3.0d0 >*/
  580.     y3 = ro * 2. * cos(fi / 3.) - a / 3.;
  581. /*<       go to 560 >*/
  582.     goto L560;
  583. /*<   550 p3=dexp(dlog(dabs(-s/2.0d0+p2))/3.0d0) >*/
  584. L550:
  585.     p3 = exp(log((d_1 = -s / 2. + p2, abs(d_1))) / 3.);
  586. /*<       p4=dexp(dlog(dabs(-s/2.0d0-p2))/3.0d0) >*/
  587.     p4 = exp(log((d_1 = -s / 2. - p2, abs(d_1))) / 3.);
  588. /*<       y3=p3+p4-a/3.0d0 >*/
  589.     y3 = p3 + p4 - a / 3.;
  590. /*<   560 iknt=0 >*/
  591. L560:
  592.     iknt = 0;
  593. /*<       a3=dsqrt(a1*a1/4.0d0-b1+y3) >*/
  594.     a3 = sqrt(a1 * a1 / 4. - b1 + y3);
  595. /*<       b3=dsqrt(y3*y3/4.0d0-d1) >*/
  596.     b3 = sqrt(y3 * y3 / 4. - d1);
  597. /*<       do 570 i=1,4 >*/
  598.     for (i = 1; i <= 4; ++i) {
  599. /*<       a4(i)=a1/2.0d0+sig1(i)*a3 >*/
  600.     a4[i - 1] = a1 / 2. + sig1[i - 1] * a3;
  601. /*<       b4(i)=y3/2.0d0+sig2(i)*b3 >*/
  602.     b4[i - 1] = y3 / 2. + sig2[i - 1] * b3;
  603. /*<       delta4=a4(i)*a4(i)/4.0d0-b4(i) >*/
  604.     delta4 = a4[i - 1] * a4[i - 1] / 4. - b4[i - 1];
  605. /*<       if (delta4.lt.0.0d0) go to 570 >*/
  606.     if (delta4 < 0.) {
  607.         goto L570;
  608.     }
  609. /*<       iknt=iknt+1 >*/
  610.     ++iknt;
  611. /*<       x4(iknt)=-a4(i)/2.0d0+dsqrt(delta4) >*/
  612.     x4[iknt - 1] = -a4[i - 1] / 2. + sqrt(delta4);
  613. /*<       iknt=iknt+1 >*/
  614.     ++iknt;
  615. /*<       x4(iknt)=-a4(i)/2.0d0-dsqrt(delta4) >*/
  616.     x4[iknt - 1] = -a4[i - 1] / 2. - sqrt(delta4);
  617. /*<   570 continue >*/
  618. L570:
  619.     ;}
  620. /*<       jknt=0 >*/
  621.     jknt = 0;
  622. /*<       do 580 j=1,iknt >*/
  623.     i_1 = iknt;
  624.     for (j = 1; j <= i_1; ++j) {
  625. /*<       if (x4(j).le.0.0d0) go to 580 >*/
  626.     if (x4[j - 1] <= 0.) {
  627.         goto L580;
  628.     }
  629. /*<       poly4(j)=x4(j)*x4(j)*x4(j)*x4(j)+a1*x4(j)*x4(j)*x4(j) >*/
  630.     poly4[j - 1] = x4[j - 1] * x4[j - 1] * x4[j - 1] * x4[j - 1] + a1 * 
  631.         x4[j - 1] * x4[j - 1] * x4[j - 1];
  632. /*<       poly4(j)=poly4(j)+b1*x4(j)*x4(j)+c1*x4(j)+d1 >*/
  633.     poly4[j - 1] = poly4[j - 1] + b1 * x4[j - 1] * x4[j - 1] + c1 * x4[j 
  634.         - 1] + d1;
  635. /*<       if (dabs(poly4(j)).gt.1.0d-6) go to 580 >*/
  636.     if ((d_1 = poly4[j - 1], abs(d_1)) > 1e-6) {
  637.         goto L580;
  638.     }
  639. /*<       jknt=jknt+1 >*/
  640.     ++jknt;
  641. /*<       if (jknt.gt.1) go to 575 >*/
  642.     if (jknt > 1) {
  643.         goto L575;
  644.     }
  645. /*<       xvalid=x4(j) >*/
  646.     xvalid = x4[j - 1];
  647. /*<   575 if (x4(j).gt.xvalid) go to 580 >*/
  648. L575:
  649.     if (x4[j - 1] > xvalid) {
  650.         goto L580;
  651.     }
  652. /*<       xvalid=x4(j) >*/
  653.     xvalid = x4[j - 1];
  654. /*<   580 continue >*/
  655. L580:
  656.     ;}
  657. /*<       if (jknt.gt.0) go to 590 >*/
  658.     if (jknt > 0) {
  659.     goto L590;
  660.     }
  661. /*<       ivmflg=ivmflg+1 >*/
  662.     ++status_1.ivmflg;
  663. /*<       go to 600 >*/
  664.     goto L600;
  665. /*<   590 vdsat=xvalid*xvalid+vbs-phi >*/
  666. L590:
  667.     mosarg_1.vdsat = xvalid * xvalid + *vbs - mosarg_1.phi;
  668.  
  669. /*  evaluate effective channel length and its derivatives */
  670.  
  671. /*<   600 if (vds.eq.0.0d0) go to 610 >*/
  672. L600:
  673.     if (*vds == 0.) {
  674.     goto L610;
  675.     }
  676. /*<       gammad=gamasd >*/
  677.     gammad = gamasd;
  678. /*<       if ((vbs-vdsat).gt.0.0d0) go to 601 >*/
  679.     if (*vbs - mosarg_1.vdsat > 0.) {
  680.     goto L601;
  681.     }
  682. /*<       bsarg=dsqrt(vdsat-vbs+phi) >*/
  683.     bsarg = sqrt(mosarg_1.vdsat - *vbs + mosarg_1.phi);
  684. /*<       dbsrdb=-0.5d0/bsarg >*/
  685.     dbsrdb = -.5 / bsarg;
  686. /*<       go to 602 >*/
  687.     goto L602;
  688. /*<   601 bsarg=sphi/(1.0d0+0.5d0*(vbs-vdsat)/phi) >*/
  689. L601:
  690.     bsarg = sphi / ((*vbs - mosarg_1.vdsat) * .5 / mosarg_1.phi + 1.);
  691. /*<       dbsrdb=-0.5d0*bsarg*bsarg/sphi3 >*/
  692.     dbsrdb = bsarg * -.5 * bsarg / sphi3;
  693. /*<   602 bodys=bsarg*bsarg*bsarg-sarg3 >*/
  694. L602:
  695.     bodys = bsarg * bsarg * bsarg - sarg3;
  696. /*<       gdbdvs=2.0d0*gammad*(bsarg*bsarg*dbsrdb-sarg*sarg*dsrgdb) >*/
  697.     gdbdvs = gammad * 2. * (bsarg * bsarg * dbsrdb - sarg * sarg * dsrgdb);
  698. /*<       if (vmax.gt.0.0d0) go to 603 >*/
  699.     if (mosarg_1.vmax > 0.) {
  700.     goto L603;
  701.     }
  702. /*<       if (xnsub.eq.0.0d0) go to 610 >*/
  703.     if (mosarg_1.xnsub == 0.) {
  704.     goto L610;
  705.     }
  706. /*<       if (xlamda.gt.0.0d0) go to 610 >*/
  707.     if (mosarg_1.xlamda > 0.) {
  708.     goto L610;
  709.     }
  710. /*<       argv=(vds-vdsat)/4.0d0 >*/
  711.     argv = (*vds - mosarg_1.vdsat) / 4.;
  712. /*<       sargv=dsqrt(1.0d0+argv*argv) >*/
  713.     sargv = sqrt(argv * argv + 1.);
  714. /*<       arg=dsqrt(argv+sargv) >*/
  715.     arg = sqrt(argv + sargv);
  716. /*<       xlfact=xd/(xl*vds) >*/
  717.     xlfact = mosarg_1.xd / (mosarg_1.xl * *vds);
  718. /*<       xlamda=xlfact*arg >*/
  719.     mosarg_1.xlamda = xlfact * arg;
  720. /*<       dldsat=vds*xlfact*arg/(8.0d0*sargv) >*/
  721.     dldsat = *vds * xlfact * arg / (sargv * 8.);
  722. /*<       go to 605 >*/
  723.     goto L605;
  724. /*<   603 argv=(vgsx-vbin)/eta-vdsat >*/
  725. L603:
  726.     argv = (vgsx - vbin) / eta - mosarg_1.vdsat;
  727. /*<       xdv=xd/dsqrt(xneff) >*/
  728.     xdv = mosarg_1.xd / sqrt(mosarg_1.xneff);
  729. /*<       xlv=vmax*xdv/(2.0d0*ueff) >*/
  730.     xlv = mosarg_1.vmax * xdv / (ueff * 2.);
  731. /*<       vqchan=argv-gammad*bsarg >*/
  732.     vqchan = argv - gammad * bsarg;
  733. /*<       dqdsat=-1.0d0+gammad*dbsrdb >*/
  734.     dqdsat = gammad * dbsrdb - 1.;
  735. /*<       vl=vmax*xl >*/
  736.     vl = mosarg_1.vmax * mosarg_1.xl;
  737. /*<       dfunds=vl*dqdsat-ueff*vqchan >*/
  738.     dfunds = vl * dqdsat - ueff * vqchan;
  739. /*<       dfundg=(vl-ueff*vdsat)/eta >*/
  740.     dfundg = (vl - ueff * mosarg_1.vdsat) / eta;
  741. /*<       dfundb=-vl*(1.0d0+dqdsat-factor/eta)+ >*/
  742. /*<      1        ueff*(gdbdvs-dgdvbs*bodys/1.5d0)/eta >*/
  743.     dfundb = -vl * (dqdsat + 1. - factor / eta) + ueff * (gdbdvs - dgdvbs * 
  744.         bodys / 1.5) / eta;
  745. /*<       dsdvgs=-dfundg/dfunds >*/
  746.     dsdvgs = -dfundg / dfunds;
  747. /*<       dsdvbs=-dfundb/dfunds >*/
  748.     dsdvbs = -dfundb / dfunds;
  749. /*<       if (xnsub.eq.0.0d0) go to 610 >*/
  750.     if (mosarg_1.xnsub == 0.) {
  751.     goto L610;
  752.     }
  753. /*<       if (xlamda.gt.0.0d0) go to 610 >*/
  754.     if (mosarg_1.xlamda > 0.) {
  755.     goto L610;
  756.     }
  757. /*<       argv=dmax1(vds-vdsat,0.0d0) >*/
  758. /* Computing MAX */
  759.     d_1 = *vds - mosarg_1.vdsat;
  760.     argv = max(0.,d_1);
  761. /*<       xls=dsqrt(xlv*xlv+argv) >*/
  762.     xls = sqrt(xlv * xlv + argv);
  763. /*<       dldsat=xdv/(2.0d0*xls) >*/
  764.     dldsat = xdv / (xls * 2.);
  765. /*<       xlfact=xdv/(xl*vds) >*/
  766.     xlfact = xdv / (mosarg_1.xl * *vds);
  767. /*<       xlamda=xlfact*(xls-xlv) >*/
  768.     mosarg_1.xlamda = xlfact * (xls - xlv);
  769. /*<       dldsat=dldsat/xl >*/
  770.     dldsat /= mosarg_1.xl;
  771. /*<   605 dldvgs=dldsat*dsdvgs >*/
  772. L605:
  773.     dldvgs = dldsat * dsdvgs;
  774. /*<       dldvds=-xlamda+dldsat >*/
  775.     dldvds = -mosarg_1.xlamda + dldsat;
  776. /*<       dldvbs=dldsat*dsdvbs >*/
  777.     dldvbs = dldsat * dsdvbs;
  778. /*<       go to 620 >*/
  779.     goto L620;
  780. /*<   610 dldvgs=0.0d0 >*/
  781. L610:
  782.     dldvgs = 0.;
  783. /*<       dldvds=0.0d0 >*/
  784.     dldvds = 0.;
  785. /*<       dldvbs=0.0d0 >*/
  786.     dldvbs = 0.;
  787.  
  788. /*     limit channel shortening at punch-through */
  789.  
  790. /*<   620 xwb=xd*sbiarg >*/
  791. L620:
  792.     xwb = mosarg_1.xd * sbiarg;
  793. /*<       xld=xl-xwb >*/
  794.     mosarg_1.xld = mosarg_1.xl - xwb;
  795. /*<       clfact=1.0d0-xlamda*vds >*/
  796.     clfact = 1. - mosarg_1.xlamda * *vds;
  797. /*<       dldvds=-xlamda-dldvds >*/
  798.     dldvds = -mosarg_1.xlamda - dldvds;
  799. /*<       xleff=xl*clfact >*/
  800.     xleff = mosarg_1.xl * clfact;
  801. /*<       deltal=xlamda*vds*xl >*/
  802.     deltal = mosarg_1.xlamda * *vds * mosarg_1.xl;
  803. /*<       if (xnsub.eq.0.0d0) xwb=0.25d-6 >*/
  804.     if (mosarg_1.xnsub == 0.) {
  805.     xwb = 2.5e-7;
  806.     }
  807. /*<       if (xleff.ge.xwb) go to 700 >*/
  808.     if (xleff >= xwb) {
  809.     goto L700;
  810.     }
  811. /*<       xleff=xwb/(1.0d0+(deltal-xld)/xwb) >*/
  812.     xleff = xwb / ((deltal - mosarg_1.xld) / xwb + 1.);
  813. /*<       clfact=xleff/xl >*/
  814.     clfact = xleff / mosarg_1.xl;
  815. /*<       dfact=xleff*xleff/(xwb*xwb) >*/
  816.     dfact = xleff * xleff / (xwb * xwb);
  817. /*<       dldvgs=dfact*dldvgs >*/
  818.     dldvgs = dfact * dldvgs;
  819. /*<       dldvds=dfact*dldvds >*/
  820.     dldvds = dfact * dldvds;
  821. /*<       dldvbs=dfact*dldvbs >*/
  822.     dldvbs = dfact * dldvbs;
  823.  
  824. /*  evaluate effective beta (effective kp) */
  825.  
  826. /*<   700 beta1=beta*ufact/clfact >*/
  827. L700:
  828.     mosarg_1.beta1 = mosarg_1.beta * ufact / clfact;
  829.  
  830. /*  test for mode of operation and branch appropriately */
  831.  
  832. /*<       gammad=gamasd >*/
  833.     gammad = gamasd;
  834. /*<       dgdvbs=dgddvb >*/
  835.     dgdvbs = dgddvb;
  836. /*<       if (vds.gt.1.0d-8) go to 730 >*/
  837.     if (*vds > 1e-8) {
  838.     goto L730;
  839.     }
  840. /*<       if (vgs.gt.von) go to 720 >*/
  841.     if (*vgs > mosarg_1.von) {
  842.     goto L720;
  843.     }
  844. /*<       if ((xnfs.ne.0.0d0).and.(cox.ne.0.0d0)) go to 710 >*/
  845.     if (mosarg_1.xnfs != 0. && mosarg_1.cox != 0.) {
  846.     goto L710;
  847.     }
  848. /*<       gds=0.0d0 >*/
  849.     *gds = 0.;
  850. /*<       go to 1050 >*/
  851.     goto L1050;
  852.  
  853. /*<   710 gds=beta1*(von-vbin-gammad*sarg)*dexp(argg*(vgs-von)) >*/
  854. L710:
  855.     *gds = mosarg_1.beta1 * (mosarg_1.von - vbin - gammad * sarg) * exp(argg *
  856.          (*vgs - mosarg_1.von));
  857. /*<       go to 1050 >*/
  858.     goto L1050;
  859.  
  860.  
  861. /*<   720 gds=beta1*(vgs-vbin-gammad*sarg) >*/
  862. L720:
  863.     *gds = mosarg_1.beta1 * (*vgs - vbin - gammad * sarg);
  864. /*<       go to 1050 >*/
  865.     goto L1050;
  866.  
  867. /*<   730 if (vgs.gt.von) go to 900 >*/
  868. L730:
  869.     if (*vgs > mosarg_1.von) {
  870.     goto L900;
  871.     }
  872.  
  873. /*  subthreshold region */
  874.  
  875. /*<       if (vdsat.gt.0.0d0) go to 830 >*/
  876.     if (mosarg_1.vdsat > 0.) {
  877.     goto L830;
  878.     }
  879. /*<       gds=0.0d0 >*/
  880.     *gds = 0.;
  881. /*<       if (vgs.gt.vth) go to 1020 >*/
  882.     if (*vgs > vth) {
  883.     goto L1020;
  884.     }
  885. /*<       go to 1050 >*/
  886.     goto L1050;
  887. /*<   830 vdson=dmin1(vdsat,vds) >*/
  888. L830:
  889.     vdson = min(mosarg_1.vdsat,*vds);
  890. /*<       if (vds.le.vdsat) go to 850 >*/
  891.     if (*vds <= mosarg_1.vdsat) {
  892.     goto L850;
  893.     }
  894. /*<       barg=bsarg >*/
  895.     barg = bsarg;
  896. /*<       dbrgdb=dbsrdb >*/
  897.     dbrgdb = dbsrdb;
  898. /*<       body=bodys >*/
  899.     body = bodys;
  900. /*<       gdbdv=gdbdvs >*/
  901.     gdbdv = gdbdvs;
  902. /*<   850 cdson=beta1*((von-vbin-eta*vdson*0.5d0)*vdson-gammad*body/1.5d0) >*/
  903. L850:
  904.     cdson = mosarg_1.beta1 * ((mosarg_1.von - vbin - eta * vdson * .5) * 
  905.         vdson - gammad * body / 1.5);
  906. /*<       didvds=beta1*(von-vbin-eta*vdson-gammad*barg) >*/
  907.     didvds = mosarg_1.beta1 * (mosarg_1.von - vbin - eta * vdson - gammad * 
  908.         barg);
  909. /*<       gdson=-cdson*dldvds/clfact-beta1*dgdvds*body/1.5d0 >*/
  910.     gdson = -cdson * dldvds / clfact - mosarg_1.beta1 * dgdvds * body / 1.5;
  911. /*<       if (vds.lt.vdsat) gdson=gdson+didvds >*/
  912.     if (*vds < mosarg_1.vdsat) {
  913.     gdson += didvds;
  914.     }
  915. /*<       gbson=-cdson*dldvbs/clfact >*/
  916. /*<      1      +beta1*(dodvbs*vdson+factor*vdson-dgdvbs*body/1.5d0-gdbdv) >*/
  917.     gbson = -cdson * dldvbs / clfact + mosarg_1.beta1 * (dodvbs * vdson + 
  918.         factor * vdson - dgdvbs * body / 1.5 - gdbdv);
  919. /*<       if (vds.gt.vdsat) gbson=gbson+didvds*dsdvbs >*/
  920.     if (*vds > mosarg_1.vdsat) {
  921.     gbson += didvds * dsdvbs;
  922.     }
  923. /*<       expg=dexp(argg*(vgs-von)) >*/
  924.     expg = exp(argg * (*vgs - mosarg_1.von));
  925. /*<       cdrain=cdson*expg >*/
  926.     mosarg_1.cdrain = cdson * expg;
  927. /*<       gmw=cdrain*argg >*/
  928.     gmw = mosarg_1.cdrain * argg;
  929. /*<       gm=gmw >*/
  930.     *gm = gmw;
  931. /*<       if (vds.gt.vdsat) gm=gmw+didvds*dsdvgs*expg >*/
  932.     if (*vds > mosarg_1.vdsat) {
  933.     *gm = gmw + didvds * dsdvgs * expg;
  934.     }
  935. /*<       gds=gdson*expg-gm*dodvds-gmw*(vgs-von)*dxndvd/xn >*/
  936.     *gds = gdson * expg - *gm * dodvds - gmw * (*vgs - mosarg_1.von) * dxndvd 
  937.         / xn;
  938. /*<       gmbs=gbson*expg-gm*dodvbs-gmw*(vgs-von)*dxndvb/xn >*/
  939.     *gmbs = gbson * expg - *gm * dodvbs - gmw * (*vgs - mosarg_1.von) * 
  940.         dxndvb / xn;
  941. /*<       go to 1020 >*/
  942.     goto L1020;
  943.  
  944.  
  945. /*<   900 if (vds.gt.vdsat) go to 1000 >*/
  946. L900:
  947.     if (*vds > mosarg_1.vdsat) {
  948.     goto L1000;
  949.     }
  950.  
  951. /*  linear region */
  952.  
  953. /*<       cdrain=beta1*((vgs-vbin-eta*vds/2.0d0)*vds-gammad*body/1.5d0) >*/
  954.     mosarg_1.cdrain = mosarg_1.beta1 * ((*vgs - vbin - eta * *vds / 2.) * *
  955.         vds - gammad * body / 1.5);
  956. /*<       arg=cdrain*(dudvgs/ufact-dldvgs/clfact) >*/
  957.     arg = mosarg_1.cdrain * (dudvgs / ufact - dldvgs / clfact);
  958. /*<       gm=arg+beta1*vds >*/
  959.     *gm = arg + mosarg_1.beta1 * *vds;
  960. /*<       arg=cdrain*(dudvds/ufact-dldvds/clfact) >*/
  961.     arg = mosarg_1.cdrain * (dudvds / ufact - dldvds / clfact);
  962. /*<       gds=arg+beta1*(vgs-vbin-eta*vds- >*/
  963. /*<      1   gammad*barg-dgdvds*body/1.5d0) >*/
  964.     *gds = arg + mosarg_1.beta1 * (*vgs - vbin - eta * *vds - gammad * barg - 
  965.         dgdvds * body / 1.5);
  966. /*<       arg=cdrain*(dudvbs/ufact-dldvbs/clfact) >*/
  967.     arg = mosarg_1.cdrain * (dudvbs / ufact - dldvbs / clfact);
  968. /*<       gmbs=arg-beta1*(gdbdv+dgdvbs*body/1.5d0-factor*vds) >*/
  969.     *gmbs = arg - mosarg_1.beta1 * (gdbdv + dgdvbs * body / 1.5 - factor * *
  970.         vds);
  971. /*<       go to 1020 >*/
  972.     goto L1020;
  973.  
  974. /*  saturation region */
  975.  
  976. /*<  1000 cdrain=beta1*((vgs-vbin-eta*vdsat/2.0d0)*vdsat-gammad*bodys/1.5d0) >*/
  977. L1000:
  978.     mosarg_1.cdrain = mosarg_1.beta1 * ((*vgs - vbin - eta * mosarg_1.vdsat / 
  979.         2.) * mosarg_1.vdsat - gammad * bodys / 1.5);
  980. /*<       arg=cdrain*(dudvgs/ufact-dldvgs/clfact) >*/
  981.     arg = mosarg_1.cdrain * (dudvgs / ufact - dldvgs / clfact);
  982. /*<       gm=arg+beta1*vdsat+ >*/
  983. /*<      1   beta1*(vgs-vbin-eta*vdsat-gammad*bsarg)*dsdvgs >*/
  984.     *gm = arg + mosarg_1.beta1 * mosarg_1.vdsat + mosarg_1.beta1 * (*vgs - 
  985.         vbin - eta * mosarg_1.vdsat - gammad * bsarg) * dsdvgs;
  986. /*<       gds=-cdrain*dldvds/clfact-beta1*dgdvds*bodys/1.5d0 >*/
  987.     *gds = -mosarg_1.cdrain * dldvds / clfact - mosarg_1.beta1 * dgdvds * 
  988.         bodys / 1.5;
  989. /*<       arg=cdrain*(dudvbs/ufact-dldvbs/clfact) >*/
  990.     arg = mosarg_1.cdrain * (dudvbs / ufact - dldvbs / clfact);
  991. /*<       gmbs=arg-beta1*(gdbdvs+dgdvbs*bodys/1.5d0-factor*vdsat)+ >*/
  992. /*<      1     beta1*(vgs-vbin-eta*vdsat-gammad*bsarg)*dsdvbs >*/
  993.     *gmbs = arg - mosarg_1.beta1 * (gdbdvs + dgdvbs * bodys / 1.5 - factor * 
  994.         mosarg_1.vdsat) + mosarg_1.beta1 * (*vgs - vbin - eta * 
  995.         mosarg_1.vdsat - gammad * bsarg) * dsdvbs;
  996.  
  997. /*     compute charges for "on" region */
  998.  
  999. /*<  1020 if (icharg.eq.0) go to 1500 >*/
  1000. L1020:
  1001.     if (icharg == 0) {
  1002.     goto L1500;
  1003.     }
  1004. /*<       if (vgs.le.vth) go to 1070 >*/
  1005.     if (*vgs <= vth) {
  1006.     goto L1070;
  1007.     }
  1008. /*<       call mqspof(vds,vbs,vgs,vpof,vdsat1,vth,vbin,gamasd, >*/
  1009. /*<      1   qg,qc,qb,cggb,cgdb,cgsb,cbgb,cbdb,cbsb) >*/
  1010.     mqspof_(vds, vbs, vgs, &vpof, &vdsat1, &vth, &vbin, &gamasd, qg, qc, qb, 
  1011.         cggb, cgdb, cgsb, cbgb, cbdb, cbsb);
  1012. /*<       go to 2000 >*/
  1013.     goto L2000;
  1014.  
  1015. /*  finish special cases */
  1016.  
  1017. /*<  1050 cdrain=0.0d0 >*/
  1018. L1050:
  1019.     mosarg_1.cdrain = 0.;
  1020. /*<       gm=0.0d0 >*/
  1021.     *gm = 0.;
  1022. /*<       gmbs=0.0d0 >*/
  1023.     *gmbs = 0.;
  1024. /*<  1070 xqc=xqco >*/
  1025. L1070:
  1026.     mosarg_1.xqc = mosarg_1.xqco;
  1027. /*<       if (icharg.eq.0) go to 1500 >*/
  1028.     if (icharg == 0) {
  1029.     goto L1500;
  1030.     }
  1031. /*<       call mosq2(vds,vbs,vgs,vdsat,vth,vbin,gamasd,cox,phi, >*/
  1032. /*<      1   qg,qc,qb,cggb,cgdb,cgsb,cbgb,cbdb,cbsb) >*/
  1033.     mosq2_(vds, vbs, vgs, &mosarg_1.vdsat, &vth, &vbin, &gamasd, &
  1034.         mosarg_1.cox, &mosarg_1.phi, qg, qc, qb, cggb, cgdb, cgsb, cbgb, 
  1035.         cbdb, cbsb);
  1036. /*<       qspof=0.0d0 >*/
  1037.     mosarg_1.qspof = 0.;
  1038. /*<       go to 2000 >*/
  1039.     goto L2000;
  1040.  
  1041. /*  finished */
  1042.  
  1043. /*<  1500 qg=0.0d0 >*/
  1044. L1500:
  1045.     *qg = 0.;
  1046. /*<       qb=0.0d0 >*/
  1047.     *qb = 0.;
  1048. /*<       qc=0.0d0 >*/
  1049.     *qc = 0.;
  1050. /*<       qspof=0.0d0 >*/
  1051.     mosarg_1.qspof = 0.;
  1052. /*<  2000 return >*/
  1053. L2000:
  1054.     return 0;
  1055. /*<       end >*/
  1056. } /* moseq2_ */
  1057.  
  1058.